{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "# Alireza KHODABAKHSH\n",
    " https://github.com/alirezakhodabakhsh\n",
    " "
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "86e5cbb6660a2811"
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Lib"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "b7e84f27ef0059bd"
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "outputs": [],
   "source": [
    "import torch\n",
    "torch.manual_seed(42)\n",
    "from torch import nn\n",
    "import random\n",
    "random.seed(42)\n",
    "from CustomDataset import ECGDataset, ECG_Normalize\n",
    "from torch.utils.data import random_split\n",
    "import torch.optim as optim\n",
    "from tqdm import tqdm\n",
    "import matplotlib.pyplot as plt\n",
    "from torch.nn.modules.module import _addindent"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-02-21T17:56:32.765919Z",
     "start_time": "2024-02-21T17:56:29.860143800Z"
    }
   },
   "id": "b76a367a96b52c97"
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Helper"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "8a89346a2b199243"
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "outputs": [],
   "source": [
    "def evaluate_classifier(model, dataloader, criterion, device='cpu'):\n",
    "    model.eval()\n",
    "    running_loss = 0.0\n",
    "    correct = 0\n",
    "    total = 0\n",
    "    with torch.no_grad():\n",
    "        for inputs, labels in dataloader:\n",
    "            inputs, labels = inputs.to(device), labels.to(device)\n",
    "            inputs, labels = inputs.float(), labels.long()\n",
    "            inputs = torch.unsqueeze(inputs, 1)\n",
    "            outputs = model(inputs)\n",
    "            loss = criterion(outputs, labels)\n",
    "\n",
    "            running_loss += loss.item()\n",
    "            _, predicted = outputs.max(1)\n",
    "            total += labels.size(0)\n",
    "            correct += predicted.eq(labels).sum().item()\n",
    "\n",
    "    val_loss = running_loss / len(dataloader)\n",
    "    val_acc = 100. * correct / total\n",
    "    return val_loss, val_acc"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-02-21T17:56:32.775581800Z",
     "start_time": "2024-02-21T17:56:32.765919Z"
    }
   },
   "id": "e307a326482d15cc"
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "outputs": [],
   "source": [
    "def plot_training_history(epochs, train_losses, train_accuracies, val_losses, val_accuracies):\n",
    "    \"\"\"\n",
    "    Plots the training and validation loss and accuracy up to the current epoch.\n",
    "    \"\"\"\n",
    "    plt.figure(figsize=(8, 4))\n",
    "\n",
    "    plt.subplot(1, 2, 1)\n",
    "    plt.plot(epochs, train_losses, label='Train Loss')\n",
    "    plt.plot(epochs, val_losses, label='Validation Loss')\n",
    "    plt.title('Loss Curve')\n",
    "    plt.xlabel('Epoch')\n",
    "    plt.ylabel('Loss')\n",
    "    plt.legend()\n",
    "\n",
    "    plt.subplot(1, 2, 2)\n",
    "    plt.plot(epochs, train_accuracies, label='Train Accuracy')\n",
    "    plt.plot(epochs, val_accuracies, label='Validation Accuracy')\n",
    "    plt.title('Accuracy Curve')\n",
    "    plt.xlabel('Epoch')\n",
    "    plt.ylabel('Accuracy (%)')\n",
    "    plt.legend()\n",
    "\n",
    "    plt.tight_layout()\n",
    "    plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-02-21T17:56:32.786422200Z",
     "start_time": "2024-02-21T17:56:32.786422200Z"
    }
   },
   "id": "87e25706d2df6004"
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Hyper"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "8397f3813443a47b"
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "outputs": [],
   "source": [
    "device = 'cuda'\n",
    "# ARGS\n",
    "length_channels = 187\n",
    "num_channels = 1\n",
    "\n",
    "num_epochs=10\n",
    "learning_rate = 0.005\n",
    "save_path=\"best_ECGNet_model.pth\""
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-02-21T18:01:07.042012400Z",
     "start_time": "2024-02-21T18:01:07.033612500Z"
    }
   },
   "id": "eb460114f96f0e48"
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Data"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "482430e33a02857c"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# Dataset Link\n",
    "\"https://www.kaggle.com/datasets/shayanfazeli/heartbeat/data?select=ptbdb_normal.csv\""
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "241506aff2836ea7"
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "initial_id",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2024-02-21T18:01:10.167515200Z",
     "start_time": "2024-02-21T18:01:07.697749300Z"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from torch.utils.data import DataLoader, random_split\n",
    "\n",
    "# Assuming ECGDataset and data_loaders are defined elsewhere\n",
    "normalize_transform = ECG_Normalize()\n",
    "\n",
    "# Create the full dataset\n",
    "full_dataset = ECGDataset(\"D:\\\\GitHub\\\\TimeEntropyNN\\\\Dataset\\\\ECG_Kaggle\\\\PTBDB\", transform=normalize_transform)\n",
    "\n",
    "# Shuffle dataset indices\n",
    "dataset_size = len(full_dataset)\n",
    "indices = list(range(dataset_size))\n",
    "np.random.shuffle(indices)\n",
    "\n",
    "# Optionally: Stratify split your dataset here if needed\n",
    "\n",
    "# Calculate sizes for train, validation, and test sets\n",
    "train_size = int(0.6 * dataset_size)\n",
    "val_size = int(0.2 * dataset_size)\n",
    "test_size = dataset_size - train_size - val_size\n",
    "\n",
    "# Split the dataset according to the shuffled indices\n",
    "train_indices, val_indices, test_indices = indices[:train_size], indices[train_size:train_size+val_size], indices[train_size+val_size:]\n",
    "\n",
    "train_dataset = torch.utils.data.Subset(full_dataset, train_indices)\n",
    "val_dataset = torch.utils.data.Subset(full_dataset, val_indices)\n",
    "test_dataset = torch.utils.data.Subset(full_dataset, test_indices)\n",
    "\n",
    "# Create dataloaders\n",
    "batch_size = 128\n",
    "train_dataloader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)\n",
    "val_dataloader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False)\n",
    "test_dataloader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Network"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "e196a8cf787e23c3"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "class Conv2dWithConstraint(nn.Conv2d):\n",
    "    def __init__(self, *args, max_norm=1, **kwargs):\n",
    "        self.max_norm = max_norm\n",
    "        super(Conv2dWithConstraint, self).__init__(*args, **kwargs)\n",
    "\n",
    "    def forward(self, x):\n",
    "        self.weight.data = torch.renorm(\n",
    "            self.weight.data, p=2, dim=0, maxnorm=self.max_norm\n",
    "        )\n",
    "        return super(Conv2dWithConstraint, self).forward(x)"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "64c5fe9797768743"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "class ECGNet(nn.Module):\n",
    "    def InitialBlocks(self, dropoutRate, *args, **kwargs):\n",
    "        block1 = nn.Sequential(\n",
    "            nn.Conv2d(1, self.F1, (1, self.kernelLength), stride=1, padding=(0, self.kernelLength // 2), bias=False),\n",
    "            nn.BatchNorm2d(self.F1, momentum=0.01, affine=True, eps=1e-3),\n",
    "\n",
    "            # DepthwiseConv2D =======================\n",
    "            Conv2dWithConstraint(self.F1, self.F1 * self.D, (self.channels, 1), max_norm=1, stride=1, padding=(0, 0),\n",
    "                                 groups=self.F1, bias=False),\n",
    "            # ========================================\n",
    "\n",
    "            nn.BatchNorm2d(self.F1 * self.D, momentum=0.01, affine=True, eps=1e-3),\n",
    "            nn.ELU(),\n",
    "            nn.AvgPool2d((1, 4), stride=4),\n",
    "            nn.Dropout(p=dropoutRate))\n",
    "        block2 = nn.Sequential(\n",
    "            # SeparableConv2D =======================\n",
    "            nn.Conv2d(self.F1 * self.D, self.F1 * self.D, (1, self.kernelLength2), stride=1,\n",
    "                      padding=(0, self.kernelLength2 // 2), bias=False, groups=self.F1 * self.D),\n",
    "            nn.Conv2d(self.F1 * self.D, self.F2, 1, padding=(0, 0), groups=1, bias=False, stride=1),\n",
    "            # ========================================\n",
    "\n",
    "            nn.BatchNorm2d(self.F2, momentum=0.01, affine=True, eps=1e-3),\n",
    "            nn.ELU(),\n",
    "            nn.AvgPool2d((1, 8), stride=8),\n",
    "            nn.Dropout(p=dropoutRate))\n",
    "        return nn.Sequential(block1, block2)\n",
    "\n",
    "\n",
    "    def ClassifierBlock(self, inputSize, n_classes):\n",
    "        return nn.Sequential(\n",
    "            nn.Linear(inputSize, n_classes, bias=False),\n",
    "            nn.Softmax(dim=1))\n",
    "\n",
    "    def CalculateOutSize(self, model, channels, samples):\n",
    "        '''\n",
    "        Calculate the output based on input size.\n",
    "        model is from nn.Module and inputSize is a array.\n",
    "        '''\n",
    "        data = torch.rand(1, 1, channels, samples)\n",
    "        model.eval()\n",
    "        out = model(data).shape\n",
    "        return out[2:]\n",
    "\n",
    "    def __init__(self, n_classes=4, channels=60, samples=151,\n",
    "                 dropoutRate=0.5, kernelLength=64, kernelLength2=16, F1=8,\n",
    "                 D=2, F2=16):\n",
    "        super(ECGNet, self).__init__()\n",
    "        self.F1 = F1\n",
    "        self.F2 = F2\n",
    "        self.D = D\n",
    "        self.samples = samples\n",
    "        self.n_classes = n_classes\n",
    "        self.channels = channels\n",
    "        self.kernelLength = kernelLength\n",
    "        self.kernelLength2 = kernelLength2\n",
    "        self.dropoutRate = dropoutRate\n",
    "\n",
    "        self.blocks = self.InitialBlocks(dropoutRate)\n",
    "        self.blockOutputSize = self.CalculateOutSize(self.blocks, channels, samples)\n",
    "        self.classifierBlock = self.ClassifierBlock(self.F2 * self.blockOutputSize[1], n_classes)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.blocks(x)\n",
    "        x = x.view(x.size()[0], -1)  # Flatten\n",
    "        x = self.classifierBlock(x)\n",
    "\n",
    "        return x\n",
    "\n",
    "def categorical_cross_entropy(y_pred, y_true):\n",
    "    # y_pred = y_pred.cuda()\n",
    "    # y_true = y_true.cuda()\n",
    "    y_pred = torch.clamp(y_pred, 1e-9, 1 - 1e-9)\n",
    "    return -(y_true * torch.log(y_pred)).sum(dim=1).mean()\n",
    "\n",
    "def torch_summarize(model, show_weights=True, show_parameters=True):\n",
    "    \"\"\"Summarizes torch model by showing trainable parameters and weights.\"\"\"\n",
    "    tmpstr = model.__class__.__name__ + ' (\\n'\n",
    "    for key, module in model._modules.items():\n",
    "        # if it contains layers let call it recursively to get params and weights\n",
    "        if type(module) in [\n",
    "            torch.nn.modules.container.Container,\n",
    "            torch.nn.modules.container.Sequential\n",
    "        ]:\n",
    "            modstr = torch_summarize(module)\n",
    "        else:\n",
    "            modstr = module.__repr__()\n",
    "        modstr = _addindent(modstr, 2)\n",
    "\n",
    "        params = sum([np.prod(p.size()) for p in module.parameters()])\n",
    "        weights = tuple([tuple(p.size()) for p in module.parameters()])\n",
    "\n",
    "        tmpstr += '  (' + key + '): ' + modstr\n",
    "        if show_weights:\n",
    "            tmpstr += ', weights={}'.format(weights)\n",
    "        if show_parameters:\n",
    "            tmpstr +=  ', parameters={}'.format(params)\n",
    "        tmpstr += '\\n'\n",
    "\n",
    "    tmpstr = tmpstr + ')'\n",
    "    return tmpstr"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "85657b8531b408a5"
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Train"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "c04381df2947a3f"
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#P_EEGNet :  1312\n"
     ]
    }
   ],
   "source": [
    "len(train_dataset)\n",
    "model = ECGNet(n_classes=2, channels=1, samples=length_channels, dropoutRate=0, \n",
    "                      kernelLength=64, kernelLength2=16, F1=8, D=2, F2=16).to(device)\n",
    "\n",
    "#model.apply(lambda m: utils.custom_normal_weights_init(m, mean=0.0, variance=0.1))\n",
    "\n",
    "print(\"#P_ECGNet : \", sum(p.numel() for p in model.parameters() if p.requires_grad))"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-02-21T18:01:10.382065200Z",
     "start_time": "2024-02-21T18:01:10.311034500Z"
    }
   },
   "id": "d29f74e4ae69d4f4"
  },
  {
   "cell_type": "markdown",
   "source": [
    "# SOlve Imlabance data"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "6c46143348fac211"
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "outputs": [],
   "source": [
    "n1 = len([label for label in full_dataset.labels if label == 0])\n",
    "n2 = len([label for label in full_dataset.labels if label == 1])\n",
    "total = n1 + n2\n",
    "\n",
    "weight_for_class_0 = total / (2.0 * n1)\n",
    "weight_for_class_1 = total / (2.0 * n2)\n",
    "weights = torch.tensor([weight_for_class_0, weight_for_class_1], dtype=torch.float)\n",
    "\n",
    "# Move weights to the same device as your model\n",
    "weights = weights.to(device)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-02-21T18:01:12.368664800Z",
     "start_time": "2024-02-21T18:01:12.353035Z"
    }
   },
   "id": "b349f3927440b55d"
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "outputs": [],
   "source": [
    "model.to(device)\n",
    "optimizer = optim.Adam(model.parameters(), lr=learning_rate)\n",
    "criterion = nn.CrossEntropyLoss(weight=weights)\n",
    "best_val_loss = float('inf')\n",
    "epochs, train_losses, train_accuracies, val_losses, val_accuracies = [], [], [], [], []"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-02-21T18:01:12.907514600Z",
     "start_time": "2024-02-21T18:01:12.888657100Z"
    }
   },
   "id": "aa5a8c3150105000"
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "outputs": [
    {
     "data": {
      "text/plain": "EEGNet(\n  (blocks): Sequential(\n    (0): Sequential(\n      (0): Conv2d(1, 8, kernel_size=(1, 64), stride=(1, 1), padding=(0, 32), bias=False)\n      (1): BatchNorm2d(8, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)\n      (2): Conv2dWithConstraint(8, 16, kernel_size=(1, 1), stride=(1, 1), groups=8, bias=False)\n      (3): BatchNorm2d(16, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)\n      (4): ELU(alpha=1.0)\n      (5): AvgPool2d(kernel_size=(1, 4), stride=4, padding=0)\n      (6): Dropout(p=0, inplace=False)\n    )\n    (1): Sequential(\n      (0): Conv2d(16, 16, kernel_size=(1, 16), stride=(1, 1), padding=(0, 8), groups=16, bias=False)\n      (1): Conv2d(16, 16, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (2): BatchNorm2d(16, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)\n      (3): ELU(alpha=1.0)\n      (4): AvgPool2d(kernel_size=(1, 8), stride=8, padding=0)\n      (5): Dropout(p=0, inplace=False)\n    )\n  )\n  (classifierBlock): Sequential(\n    (0): Linear(in_features=96, out_features=2, bias=False)\n    (1): Softmax(dim=1)\n  )\n)"
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-02-21T18:01:13.763700900Z",
     "start_time": "2024-02-21T18:01:13.728015Z"
    }
   },
   "id": "964af45126d22416"
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "outputs": [],
   "source": [
    "init_epoch = 0\n",
    "num_epochs = 50\n",
    "learning_rate = 0.005"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-02-21T18:12:15.855610Z",
     "start_time": "2024-02-21T18:12:15.818391600Z"
    }
   },
   "id": "d40376661716b78f"
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                            \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 299 | Train Loss: 0.3456 | Train Acc: 97.17% | Val Loss: 0.3580 | Val Acc: 95.88%\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 800x400 with 2 Axes>",
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "for epoch in range(init_epoch, init_epoch + num_epochs):\n",
    "    model.train()\n",
    "    running_loss = 0.0\n",
    "    correct = 0\n",
    "    total = 0\n",
    "    for inputs, labels in tqdm(train_dataloader, desc=f'Epoch {epoch + 1}/{num_epochs}', leave=False):\n",
    "        inputs, labels = inputs.to(device), labels.to(device)\n",
    "        inputs, labels = inputs.float(), labels.long()\n",
    "        inputs = torch.unsqueeze(inputs, 1)\n",
    "        optimizer.zero_grad()\n",
    "        outputs = model(inputs)\n",
    "        loss = criterion(outputs, labels)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        running_loss += loss.item()\n",
    "        _, predicted = outputs.max(1)\n",
    "        total += labels.size(0)\n",
    "        correct += predicted.eq(labels).sum().item()\n",
    "\n",
    "    train_loss = running_loss / len(train_dataloader)\n",
    "    train_acc = 100. * correct / total\n",
    "    train_losses.append(train_loss)\n",
    "    train_accuracies.append(train_acc)\n",
    "\n",
    "    # Evaluate on validation set\n",
    "    val_loss, val_acc = evaluate_classifier(model, val_dataloader, criterion, device=device)\n",
    "    val_losses.append(val_loss)\n",
    "    val_accuracies.append(val_acc)\n",
    "    epochs.append(epoch + 1)\n",
    "\n",
    "    print(f\"Epoch: {epoch+1} | Train Loss: {train_loss:.4f} | Train Acc: {train_acc:.2f}% | \"\n",
    "          f\"Val Loss: {val_loss:.4f} | Val Acc: {val_acc:.2f}%\")\n",
    "\n",
    "    # Save the best model based on validation accuracy\n",
    "    if val_loss < best_val_loss:\n",
    "        print(\"Validation loss improved. Saving the model...\")\n",
    "        torch.save(model.state_dict(), save_path)\n",
    "        best_val_loss = val_loss\n",
    "    \n",
    "    plot_training_history(epochs, train_losses, train_accuracies, val_losses, val_accuracies)\n"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-02-21T18:12:17.794103600Z",
     "start_time": "2024-02-21T18:12:16.308098400Z"
    }
   },
   "id": "5ebec69f9b0024d7"
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Test"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "28d64265429b9ea3"
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Loss: 0.3589 | Test Acc: 96.26%\n"
     ]
    }
   ],
   "source": [
    "# Evaluate on validation set\n",
    "test_loss, test_acc = evaluate_classifier(model, test_dataloader, criterion, device=device)\n",
    "\n",
    "\n",
    "print(f\"Test Loss: {test_loss:.4f} | Test Acc: {test_acc:.2f}%\")"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-02-21T18:13:55.899096900Z",
     "start_time": "2024-02-21T18:13:55.484372900Z"
    }
   },
   "id": "4e5a90fe6c2abad6"
  },
  {
   "cell_type": "markdown",
   "source": [
    "# END"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "3adcd83f68901ec9"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [],
   "metadata": {
    "collapsed": false
   },
   "id": "382a596287fd9149"
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
